export const uniqueId = (prefix = 'low') => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    const r = Math.random() * 16 | 0;
    const v = c === 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
}
export const cloneDeep = (obj: any) => {
  return JSON.parse(JSON.stringify(obj))
}
export const updatePrimaryKey = (item) => {
  // item = cloneDeep(item)
  if (item._id) {
    item._id = uniqueId();
  }

  // 如果对象是容器类型，递归更新其子项的 id
  if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
    item.properties["x-component-props"].items.forEach(item => {
      updatePrimaryKey(item);
    });
  }
  return item
}
export function moveItemDownById(data, idToMove) {
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];
    
    // 如果找到匹配的 id
    if (item._id === idToMove) {
      // 如果是最后一个元素，无法向下移动
      if (i === data.length - 1) {
        return false;
      }
      
      // 与后一个元素交换位置
      [data[i], data[i + 1]] = [data[i + 1], data[i]];
      return true; // 返回 true 表示移动成功
    }
    
    // 如果对象是容器类型，递归检查其子项
    if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
      const moved = moveItemDownById(item.properties["x-component-props"].items, idToMove);
      if (moved) {
        return true; // 子项中移动成功
      }
    }
  }
  
  return false; // 未找到匹配的 id 或无法移动
}
export function moveItemUpById(data, idToMove) {
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];
    
    // 如果找到匹配的 id
    if (item._id === idToMove) {
      // 如果是第一个元素，无法向上移动
      if (i === 0) {
        return false;
      }
      
      // 与前一个元素交换位置
      [data[i], data[i - 1]] = [data[i - 1], data[i]];
      return true; // 返回 true 表示移动成功
    }
    
    // 如果对象是容器类型，递归检查其子项
    if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
      const moved = moveItemUpById(item.properties["x-component-props"].items, idToMove);
      if (moved) {
        return true; // 子项中移动成功
      }
    }
  }
  
  return false; // 未找到匹配的 id 或无法移动
}

// export const findParentSchema = (schema,_id:string)=>{
//    for(let i=0;i<schema.length;i++){
//        let parentSchema = schema[i];
//        if(parentSchema._id==_id){
//         return parentSchema
//        }
//        if(parentSchema.isContainer){

//        }
//    }

// }

function findItemById(items, id) {
  for (let item of items) {
    if (item._id === id) {
      return item;
    }
    if (item.properties && item.properties['x-component-props'] && item.properties['x-component-props'].items) {
      const foundItem = findItemById(item.properties['x-component-props'].items, id);
      if (foundItem) {
        return foundItem;
      }
    }
  }
  return null;
}
export function removeItemById(items, idToRemove) {
  // 遍历数组
  for (let i = 0; i < items.length; i++) {
    const item = items[i];

    // 如果找到匹配的 id，从数组中删除该对象
    if (item._id === idToRemove) {
      items.splice(i, 1);
      return true; // 返回 true 表示删除成功
    }

    // 如果对象是容器类型，递归检查其子项
    if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
      const removed = removeItemById(item.properties["x-component-props"].items, idToRemove);
      if (removed) {
        return true; // 子项中删除成功
      }
    }
  }

  return false; // 未找到匹配的 id
}


export function copyAndAddItemById(data, idToCopy) {
  // 遍历数组
  for (let i = 0; i < data.length; i++) {
    const item = data[i];

    // 如果找到匹配的 id，复制该对象
    if (item._id === idToCopy) {
      // 深拷贝对象
      let copiedItem = updatePrimaryKey(cloneDeep(item));



      // 添加到原数组
      data.push(copiedItem);
      return true; // 返回 true 表示操作成功
    }

    // 如果对象是容器类型，递归检查其子项
    if (item.isContainer && item.properties && item.properties["x-component-props"] && item.properties["x-component-props"].items) {
      const added = copyAndAddItemById(item.properties["x-component-props"].items, idToCopy);
      if (added) {
        return true; // 子项中操作成功
      }
    }
  }

  return false; // 未找到匹配的 id
}

export function findContainerById(items, id) {
  if (!id) {
    return null
  }
  const item = findItemById(items, id);
  if (!item) {
    return null
  }
  if (item.isContainer) {
    return item;
  }
  // 如果当前项不是容器，向上查找父容器
  return findParentContainer(items, item);
}

function findParentContainer(items, item) {
  for (let parent of items) {
    if (parent.properties && parent.properties['x-component-props'] && parent.properties['x-component-props'].items) {
      for (let child of parent.properties['x-component-props'].items) {
        if (child === item) {
          return parent;
        }
        const parentContainer = findParentContainer(parent.properties['x-component-props'].items, item);
        if (parentContainer) {
          return parentContainer;
        }
      }
    }
  }
  return null;
}